home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / pickletester.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  30KB  |  826 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import unittest
  5. import pickle
  6. import cPickle
  7. import pickletools
  8. import copy_reg
  9. from test.test_support import TestFailed, have_unicode, TESTFN
  10. protocols = range(pickle.HIGHEST_PROTOCOL + 1)
  11.  
  12. def opcode_in_pickle(code, pickle):
  13.     for op, dummy, dummy in pickletools.genops(pickle):
  14.         if op.code == code:
  15.             return True
  16.             continue
  17.     
  18.     return False
  19.  
  20.  
  21. def count_opcode(code, pickle):
  22.     n = 0
  23.     for op, dummy, dummy in pickletools.genops(pickle):
  24.         if op.code == code:
  25.             n += 1
  26.             continue
  27.     
  28.     return n
  29.  
  30.  
  31. class ExtensionSaver:
  32.     
  33.     def __init__(self, code):
  34.         self.code = code
  35.         if code in copy_reg._inverted_registry:
  36.             self.pair = copy_reg._inverted_registry[code]
  37.             copy_reg.remove_extension(self.pair[0], self.pair[1], code)
  38.         else:
  39.             self.pair = None
  40.  
  41.     
  42.     def restore(self):
  43.         code = self.code
  44.         curpair = copy_reg._inverted_registry.get(code)
  45.         if curpair is not None:
  46.             copy_reg.remove_extension(curpair[0], curpair[1], code)
  47.         
  48.         pair = self.pair
  49.         if pair is not None:
  50.             copy_reg.add_extension(pair[0], pair[1], code)
  51.         
  52.  
  53.  
  54.  
  55. class C:
  56.     
  57.     def __cmp__(self, other):
  58.         return cmp(self.__dict__, other.__dict__)
  59.  
  60.  
  61. import __main__
  62. __main__.C = C
  63. C.__module__ = '__main__'
  64.  
  65. class myint(int):
  66.     
  67.     def __init__(self, x):
  68.         self.str = str(x)
  69.  
  70.  
  71.  
  72. class initarg(C):
  73.     
  74.     def __init__(self, a, b):
  75.         self.a = a
  76.         self.b = b
  77.  
  78.     
  79.     def __getinitargs__(self):
  80.         return (self.a, self.b)
  81.  
  82.  
  83.  
  84. class metaclass(type):
  85.     pass
  86.  
  87.  
  88. class use_metaclass(object):
  89.     __metaclass__ = metaclass
  90.  
  91. DATA0 = '(lp1\nI0\naL1L\naF2\nac__builtin__\ncomplex\np2\n' + '(F3\nF0\ntRp3\naI1\naI-1\naI255\naI-255\naI-256\naI65535\naI-65535\naI-65536\naI2147483647\naI-2147483647\naI-2147483648\na' + "(S'abc'\np4\ng4\n" + '(i__main__\nC\np5\n' + "(dp6\nS'foo'\np7\nI1\nsS'bar'\np8\nI2\nsbg5\ntp9\nag9\naI5\na.\n"
  92. DATA0_DIS = "    0: (    MARK\n    1: l        LIST       (MARK at 0)\n    2: p    PUT        1\n    5: I    INT        0\n    8: a    APPEND\n    9: L    LONG       1L\n   13: a    APPEND\n   14: F    FLOAT      2.0\n   17: a    APPEND\n   18: c    GLOBAL     '__builtin__ complex'\n   39: p    PUT        2\n   42: (    MARK\n   43: F        FLOAT      3.0\n   46: F        FLOAT      0.0\n   49: t        TUPLE      (MARK at 42)\n   50: R    REDUCE\n   51: p    PUT        3\n   54: a    APPEND\n   55: I    INT        1\n   58: a    APPEND\n   59: I    INT        -1\n   63: a    APPEND\n   64: I    INT        255\n   69: a    APPEND\n   70: I    INT        -255\n   76: a    APPEND\n   77: I    INT        -256\n   83: a    APPEND\n   84: I    INT        65535\n   91: a    APPEND\n   92: I    INT        -65535\n  100: a    APPEND\n  101: I    INT        -65536\n  109: a    APPEND\n  110: I    INT        2147483647\n  122: a    APPEND\n  123: I    INT        -2147483647\n  136: a    APPEND\n  137: I    INT        -2147483648\n  150: a    APPEND\n  151: (    MARK\n  152: S        STRING     'abc'\n  159: p        PUT        4\n  162: g        GET        4\n  165: (        MARK\n  166: i            INST       '__main__ C' (MARK at 165)\n  178: p        PUT        5\n  181: (        MARK\n  182: d            DICT       (MARK at 181)\n  183: p        PUT        6\n  186: S        STRING     'foo'\n  193: p        PUT        7\n  196: I        INT        1\n  199: s        SETITEM\n  200: S        STRING     'bar'\n  207: p        PUT        8\n  210: I        INT        2\n  213: s        SETITEM\n  214: b        BUILD\n  215: g        GET        5\n  218: t        TUPLE      (MARK at 151)\n  219: p    PUT        9\n  222: a    APPEND\n  223: g    GET        9\n  226: a    APPEND\n  227: I    INT        5\n  230: a    APPEND\n  231: .    STOP\nhighest protocol among opcodes = 0\n"
  93. DATA1 = ']q\x01(K\x00L1L\nG@\x00\x00\x00\x00\x00\x00\x00c__builtin__\ncomplex\nq\x02(G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00tRq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\nC\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh\x06tq\nh\nK\x05e.'
  94. DATA1_DIS = "    0: ]    EMPTY_LIST\n    1: q    BINPUT     1\n    3: (    MARK\n    4: K        BININT1    0\n    6: L        LONG       1L\n   10: G        BINFLOAT   2.0\n   19: c        GLOBAL     '__builtin__ complex'\n   40: q        BINPUT     2\n   42: (        MARK\n   43: G            BINFLOAT   3.0\n   52: G            BINFLOAT   0.0\n   61: t            TUPLE      (MARK at 42)\n   62: R        REDUCE\n   63: q        BINPUT     3\n   65: K        BININT1    1\n   67: J        BININT     -1\n   72: K        BININT1    255\n   74: J        BININT     -255\n   79: J        BININT     -256\n   84: M        BININT2    65535\n   87: J        BININT     -65535\n   92: J        BININT     -65536\n   97: J        BININT     2147483647\n  102: J        BININT     -2147483647\n  107: J        BININT     -2147483648\n  112: (        MARK\n  113: U            SHORT_BINSTRING 'abc'\n  118: q            BINPUT     4\n  120: h            BINGET     4\n  122: (            MARK\n  123: c                GLOBAL     '__main__ C'\n  135: q                BINPUT     5\n  137: o                OBJ        (MARK at 122)\n  138: q            BINPUT     6\n  140: }            EMPTY_DICT\n  141: q            BINPUT     7\n  143: (            MARK\n  144: U                SHORT_BINSTRING 'foo'\n  149: q                BINPUT     8\n  151: K                BININT1    1\n  153: U                SHORT_BINSTRING 'bar'\n  158: q                BINPUT     9\n  160: K                BININT1    2\n  162: u                SETITEMS   (MARK at 143)\n  163: b            BUILD\n  164: h            BINGET     6\n  166: t            TUPLE      (MARK at 112)\n  167: q        BINPUT     10\n  169: h        BINGET     10\n  171: K        BININT1    5\n  173: e        APPENDS    (MARK at 3)\n  174: .    STOP\nhighest protocol among opcodes = 1\n"
  95. DATA2 = '\x80\x02]q\x01(K\x00\x8a\x01\x01G@\x00\x00\x00\x00\x00\x00\x00c__builtin__\ncomplex\nq\x02G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00\x86Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\nC\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh\x06tq\nh\nK\x05e.'
  96. DATA2_DIS = "    0: \x80 PROTO      2\n    2: ]    EMPTY_LIST\n    3: q    BINPUT     1\n    5: (    MARK\n    6: K        BININT1    0\n    8: \x8a     LONG1      1L\n   11: G        BINFLOAT   2.0\n   20: c        GLOBAL     '__builtin__ complex'\n   41: q        BINPUT     2\n   43: G        BINFLOAT   3.0\n   52: G        BINFLOAT   0.0\n   61: \x86     TUPLE2\n   62: R        REDUCE\n   63: q        BINPUT     3\n   65: K        BININT1    1\n   67: J        BININT     -1\n   72: K        BININT1    255\n   74: J        BININT     -255\n   79: J        BININT     -256\n   84: M        BININT2    65535\n   87: J        BININT     -65535\n   92: J        BININT     -65536\n   97: J        BININT     2147483647\n  102: J        BININT     -2147483647\n  107: J        BININT     -2147483648\n  112: (        MARK\n  113: U            SHORT_BINSTRING 'abc'\n  118: q            BINPUT     4\n  120: h            BINGET     4\n  122: (            MARK\n  123: c                GLOBAL     '__main__ C'\n  135: q                BINPUT     5\n  137: o                OBJ        (MARK at 122)\n  138: q            BINPUT     6\n  140: }            EMPTY_DICT\n  141: q            BINPUT     7\n  143: (            MARK\n  144: U                SHORT_BINSTRING 'foo'\n  149: q                BINPUT     8\n  151: K                BININT1    1\n  153: U                SHORT_BINSTRING 'bar'\n  158: q                BINPUT     9\n  160: K                BININT1    2\n  162: u                SETITEMS   (MARK at 143)\n  163: b            BUILD\n  164: h            BINGET     6\n  166: t            TUPLE      (MARK at 112)\n  167: q        BINPUT     10\n  169: h        BINGET     10\n  171: K        BININT1    5\n  173: e        APPENDS    (MARK at 5)\n  174: .    STOP\nhighest protocol among opcodes = 2\n"
  97.  
  98. def create_data():
  99.     c = C()
  100.     c.foo = 1
  101.     c.bar = 2
  102.     x = [
  103.         0,
  104.         0x1L,
  105.         2.0,
  106.         3.0 + (0.0+0.0j)]
  107.     uint1max = 255
  108.     uint2max = 65535
  109.     int4max = 2147483647
  110.     x.extend([
  111.         1,
  112.         -1,
  113.         uint1max,
  114.         -uint1max,
  115.         -uint1max - 1,
  116.         uint2max,
  117.         -uint2max,
  118.         -uint2max - 1,
  119.         int4max,
  120.         -int4max,
  121.         -int4max - 1])
  122.     y = ('abc', 'abc', c, c)
  123.     x.append(y)
  124.     x.append(y)
  125.     x.append(5)
  126.     return x
  127.  
  128.  
  129. class AbstractPickleTests(unittest.TestCase):
  130.     _testdata = create_data()
  131.     
  132.     def setUp(self):
  133.         pass
  134.  
  135.     
  136.     def test_misc(self):
  137.         for proto in protocols:
  138.             x = myint(4)
  139.             s = self.dumps(x, proto)
  140.             y = self.loads(s)
  141.             self.assertEqual(x, y)
  142.             x = (1, ())
  143.             s = self.dumps(x, proto)
  144.             y = self.loads(s)
  145.             self.assertEqual(x, y)
  146.             x = initarg(1, x)
  147.             s = self.dumps(x, proto)
  148.             y = self.loads(s)
  149.             self.assertEqual(x, y)
  150.         
  151.  
  152.     
  153.     def test_roundtrip_equality(self):
  154.         expected = self._testdata
  155.         for proto in protocols:
  156.             s = self.dumps(expected, proto)
  157.             got = self.loads(s)
  158.             self.assertEqual(expected, got)
  159.         
  160.  
  161.     
  162.     def test_load_from_canned_string(self):
  163.         expected = self._testdata
  164.         for canned in (DATA0, DATA1, DATA2):
  165.             got = self.loads(canned)
  166.             self.assertEqual(expected, got)
  167.         
  168.  
  169.     
  170.     def dont_test_disassembly(self):
  171.         StringIO = StringIO
  172.         import cStringIO
  173.         dis = dis
  174.         import pickletools
  175.         for proto, expected in ((0, DATA0_DIS), (1, DATA1_DIS)):
  176.             s = self.dumps(self._testdata, proto)
  177.             filelike = StringIO()
  178.             dis(s, out = filelike)
  179.             got = filelike.getvalue()
  180.             self.assertEqual(expected, got)
  181.         
  182.  
  183.     
  184.     def test_recursive_list(self):
  185.         l = []
  186.         l.append(l)
  187.         for proto in protocols:
  188.             s = self.dumps(l, proto)
  189.             x = self.loads(s)
  190.             self.assertEqual(len(x), 1)
  191.             self.assert_(x is x[0])
  192.         
  193.  
  194.     
  195.     def test_recursive_dict(self):
  196.         d = { }
  197.         d[1] = d
  198.         for proto in protocols:
  199.             s = self.dumps(d, proto)
  200.             x = self.loads(s)
  201.             self.assertEqual(x.keys(), [
  202.                 1])
  203.             self.assert_(x[1] is x)
  204.         
  205.  
  206.     
  207.     def test_recursive_inst(self):
  208.         i = C()
  209.         i.attr = i
  210.         for proto in protocols:
  211.             s = self.dumps(i, 2)
  212.             x = self.loads(s)
  213.             self.assertEqual(dir(x), dir(i))
  214.             self.assert_(x.attr is x)
  215.         
  216.  
  217.     
  218.     def test_recursive_multi(self):
  219.         l = []
  220.         d = {
  221.             1: l }
  222.         i = C()
  223.         i.attr = d
  224.         l.append(i)
  225.         for proto in protocols:
  226.             s = self.dumps(l, proto)
  227.             x = self.loads(s)
  228.             self.assertEqual(len(x), 1)
  229.             self.assertEqual(dir(x[0]), dir(i))
  230.             self.assertEqual(x[0].attr.keys(), [
  231.                 1])
  232.             self.assert_(x[0].attr[1] is x)
  233.         
  234.  
  235.     
  236.     def test_garyp(self):
  237.         self.assertRaises(self.error, self.loads, 'garyp')
  238.  
  239.     
  240.     def test_insecure_strings(self):
  241.         insecure = [
  242.             'abc',
  243.             '2 + 2',
  244.             "'abc",
  245.             '\'abc"',
  246.             "'abc'   ?",
  247.             "'\\'"]
  248.         for s in insecure:
  249.             buf = 'S' + s + '\np0\n.'
  250.             self.assertRaises(ValueError, self.loads, buf)
  251.         
  252.  
  253.     if have_unicode:
  254.         
  255.         def test_unicode(self):
  256.             endcases = [
  257.                 unicode(''),
  258.                 unicode('<\\u>'),
  259.                 unicode('<\\\\u1234>'),
  260.                 unicode('<\n>'),
  261.                 unicode('<\\>')]
  262.             for proto in protocols:
  263.                 for u in endcases:
  264.                     p = self.dumps(u, proto)
  265.                     u2 = self.loads(p)
  266.                     self.assertEqual(u2, u)
  267.                 
  268.             
  269.  
  270.     
  271.     
  272.     def test_ints(self):
  273.         import sys as sys
  274.         for proto in protocols:
  275.             n = sys.maxint
  276.             while n:
  277.                 for expected in (-n, n):
  278.                     s = self.dumps(expected, proto)
  279.                     n2 = self.loads(s)
  280.                     self.assertEqual(expected, n2)
  281.                 
  282.                 n = n >> 1
  283.         
  284.  
  285.     
  286.     def test_maxint64(self):
  287.         maxint64 = (0x1L << 63) - 1
  288.         data = 'I' + str(maxint64) + '\n.'
  289.         got = self.loads(data)
  290.         self.assertEqual(got, maxint64)
  291.         data = 'I' + str(maxint64) + 'JUNK\n.'
  292.         self.assertRaises(ValueError, self.loads, data)
  293.  
  294.     
  295.     def test_long(self):
  296.         for proto in protocols:
  297.             for nbits in (1, 8, 8 * 254, 8 * 255, 8 * 256, 8 * 257):
  298.                 nbase = 0x1L << nbits
  299.                 for npos in (nbase - 1, nbase, nbase + 1):
  300.                     for n in (npos, -npos):
  301.                         pickle = self.dumps(n, proto)
  302.                         got = self.loads(pickle)
  303.                         self.assertEqual(n, got)
  304.                     
  305.                 
  306.             
  307.         
  308.         nbase = long('deadbeeffeedface', 16)
  309.         nbase += nbase << 1000000
  310.         for n in (nbase, -nbase):
  311.             p = self.dumps(n, 2)
  312.             got = self.loads(p)
  313.             self.assertEqual(n, got)
  314.         
  315.  
  316.     
  317.     def test_reduce(self):
  318.         pass
  319.  
  320.     
  321.     def test_getinitargs(self):
  322.         pass
  323.  
  324.     
  325.     def test_metaclass(self):
  326.         a = use_metaclass()
  327.         for proto in protocols:
  328.             s = self.dumps(a, proto)
  329.             b = self.loads(s)
  330.             self.assertEqual(a.__class__, b.__class__)
  331.         
  332.  
  333.     
  334.     def test_structseq(self):
  335.         import time as time
  336.         import os as os
  337.         t = time.localtime()
  338.         for proto in protocols:
  339.             s = self.dumps(t, proto)
  340.             u = self.loads(s)
  341.             self.assertEqual(t, u)
  342.             if hasattr(os, 'stat'):
  343.                 t = os.stat(os.curdir)
  344.                 s = self.dumps(t, proto)
  345.                 u = self.loads(s)
  346.                 self.assertEqual(t, u)
  347.             
  348.             if hasattr(os, 'statvfs'):
  349.                 t = os.statvfs(os.curdir)
  350.                 s = self.dumps(t, proto)
  351.                 u = self.loads(s)
  352.                 self.assertEqual(t, u)
  353.                 continue
  354.         
  355.  
  356.     
  357.     def test_proto(self):
  358.         build_none = pickle.NONE + pickle.STOP
  359.         for proto in protocols:
  360.             expected = build_none
  361.             if proto >= 2:
  362.                 expected = pickle.PROTO + chr(proto) + expected
  363.             
  364.             p = self.dumps(None, proto)
  365.             self.assertEqual(p, expected)
  366.         
  367.         oob = protocols[-1] + 1
  368.         badpickle = pickle.PROTO + chr(oob) + build_none
  369.         
  370.         try:
  371.             self.loads(badpickle)
  372.         except ValueError:
  373.             detail = None
  374.             self.failUnless(str(detail).startswith('unsupported pickle protocol'))
  375.  
  376.         self.fail('expected bad protocol number to raise ValueError')
  377.  
  378.     
  379.     def test_long1(self):
  380.         x = 0x27E41B32C1EEF784CCA555E8L
  381.         for proto in protocols:
  382.             s = self.dumps(x, proto)
  383.             y = self.loads(s)
  384.             self.assertEqual(x, y)
  385.             self.assertEqual(opcode_in_pickle(pickle.LONG1, s), proto >= 2)
  386.         
  387.  
  388.     
  389.     def test_long4(self):
  390.         x = 0x27E41B32C1EEF784CCA555E8L << 256 * 8
  391.         for proto in protocols:
  392.             s = self.dumps(x, proto)
  393.             y = self.loads(s)
  394.             self.assertEqual(x, y)
  395.             self.assertEqual(opcode_in_pickle(pickle.LONG4, s), proto >= 2)
  396.         
  397.  
  398.     
  399.     def test_short_tuples(self):
  400.         expected_opcode = {
  401.             (0, 0): pickle.TUPLE,
  402.             (0, 1): pickle.TUPLE,
  403.             (0, 2): pickle.TUPLE,
  404.             (0, 3): pickle.TUPLE,
  405.             (0, 4): pickle.TUPLE,
  406.             (1, 0): pickle.EMPTY_TUPLE,
  407.             (1, 1): pickle.TUPLE,
  408.             (1, 2): pickle.TUPLE,
  409.             (1, 3): pickle.TUPLE,
  410.             (1, 4): pickle.TUPLE,
  411.             (2, 0): pickle.EMPTY_TUPLE,
  412.             (2, 1): pickle.TUPLE1,
  413.             (2, 2): pickle.TUPLE2,
  414.             (2, 3): pickle.TUPLE3,
  415.             (2, 4): pickle.TUPLE }
  416.         a = ()
  417.         b = (1,)
  418.         c = (1, 2)
  419.         d = (1, 2, 3)
  420.         e = (1, 2, 3, 4)
  421.         for proto in protocols:
  422.             for x in (a, b, c, d, e):
  423.                 s = self.dumps(x, proto)
  424.                 y = self.loads(s)
  425.                 self.assertEqual(x, y, (proto, x, s, y))
  426.                 expected = expected_opcode[(proto, len(x))]
  427.                 self.assertEqual(opcode_in_pickle(expected, s), True)
  428.             
  429.         
  430.  
  431.     
  432.     def test_singletons(self):
  433.         expected_opcode = {
  434.             (0, None): pickle.NONE,
  435.             (1, None): pickle.NONE,
  436.             (2, None): pickle.NONE,
  437.             (0, True): pickle.INT,
  438.             (1, True): pickle.INT,
  439.             (2, True): pickle.NEWTRUE,
  440.             (0, False): pickle.INT,
  441.             (1, False): pickle.INT,
  442.             (2, False): pickle.NEWFALSE }
  443.         for proto in protocols:
  444.             for x in (None, False, True):
  445.                 s = self.dumps(x, proto)
  446.                 y = self.loads(s)
  447.                 self.assert_(x is y, (proto, x, s, y))
  448.                 expected = expected_opcode[(proto, x)]
  449.                 self.assertEqual(opcode_in_pickle(expected, s), True)
  450.             
  451.         
  452.  
  453.     
  454.     def test_newobj_tuple(self):
  455.         x = MyTuple([
  456.             1,
  457.             2,
  458.             3])
  459.         x.foo = 42
  460.         x.bar = 'hello'
  461.         for proto in protocols:
  462.             s = self.dumps(x, proto)
  463.             y = self.loads(s)
  464.             self.assertEqual(tuple(x), tuple(y))
  465.             self.assertEqual(x.__dict__, y.__dict__)
  466.         
  467.  
  468.     
  469.     def test_newobj_list(self):
  470.         x = MyList([
  471.             1,
  472.             2,
  473.             3])
  474.         x.foo = 42
  475.         x.bar = 'hello'
  476.         for proto in protocols:
  477.             s = self.dumps(x, proto)
  478.             y = self.loads(s)
  479.             self.assertEqual(list(x), list(y))
  480.             self.assertEqual(x.__dict__, y.__dict__)
  481.         
  482.  
  483.     
  484.     def test_newobj_generic(self):
  485.         for proto in protocols:
  486.             for C in myclasses:
  487.                 B = C.__base__
  488.                 x = C(C.sample)
  489.                 x.foo = 42
  490.                 s = self.dumps(x, proto)
  491.                 y = self.loads(s)
  492.                 detail = (proto, C, B, x, y, type(y))
  493.                 self.assertEqual(B(x), B(y), detail)
  494.                 self.assertEqual(x.__dict__, y.__dict__, detail)
  495.             
  496.         
  497.  
  498.     
  499.     def produce_global_ext(self, extcode, opcode):
  500.         e = ExtensionSaver(extcode)
  501.         
  502.         try:
  503.             copy_reg.add_extension(__name__, 'MyList', extcode)
  504.             x = MyList([
  505.                 1,
  506.                 2,
  507.                 3])
  508.             x.foo = 42
  509.             x.bar = 'hello'
  510.             s1 = self.dumps(x, 1)
  511.             self.assert_(__name__ in s1)
  512.             self.assert_('MyList' in s1)
  513.             self.assertEqual(opcode_in_pickle(opcode, s1), False)
  514.             y = self.loads(s1)
  515.             self.assertEqual(list(x), list(y))
  516.             self.assertEqual(x.__dict__, y.__dict__)
  517.             s2 = self.dumps(x, 2)
  518.             self.assert_(__name__ not in s2)
  519.             self.assert_('MyList' not in s2)
  520.             self.assertEqual(opcode_in_pickle(opcode, s2), True)
  521.             y = self.loads(s2)
  522.             self.assertEqual(list(x), list(y))
  523.             self.assertEqual(x.__dict__, y.__dict__)
  524.         finally:
  525.             e.restore()
  526.  
  527.  
  528.     
  529.     def test_global_ext1(self):
  530.         self.produce_global_ext(1, pickle.EXT1)
  531.         self.produce_global_ext(255, pickle.EXT1)
  532.  
  533.     
  534.     def test_global_ext2(self):
  535.         self.produce_global_ext(256, pickle.EXT2)
  536.         self.produce_global_ext(65535, pickle.EXT2)
  537.         self.produce_global_ext(43981, pickle.EXT2)
  538.  
  539.     
  540.     def test_global_ext4(self):
  541.         self.produce_global_ext(65536, pickle.EXT4)
  542.         self.produce_global_ext(2147483647, pickle.EXT4)
  543.         self.produce_global_ext(313249263, pickle.EXT4)
  544.  
  545.     
  546.     def test_list_chunking(self):
  547.         n = 10
  548.         x = range(n)
  549.         for proto in protocols:
  550.             s = self.dumps(x, proto)
  551.             y = self.loads(s)
  552.             self.assertEqual(x, y)
  553.             num_appends = count_opcode(pickle.APPENDS, s)
  554.             self.assertEqual(num_appends, proto > 0)
  555.         
  556.         n = 2500
  557.         x = range(n)
  558.         for proto in protocols:
  559.             s = self.dumps(x, proto)
  560.             y = self.loads(s)
  561.             self.assertEqual(x, y)
  562.             num_appends = count_opcode(pickle.APPENDS, s)
  563.             if proto == 0:
  564.                 self.assertEqual(num_appends, 0)
  565.                 continue
  566.             self.failUnless(num_appends >= 2)
  567.         
  568.  
  569.     
  570.     def test_dict_chunking(self):
  571.         n = 10
  572.         x = dict.fromkeys(range(n))
  573.         for proto in protocols:
  574.             s = self.dumps(x, proto)
  575.             y = self.loads(s)
  576.             self.assertEqual(x, y)
  577.             num_setitems = count_opcode(pickle.SETITEMS, s)
  578.             self.assertEqual(num_setitems, proto > 0)
  579.         
  580.         n = 2500
  581.         x = dict.fromkeys(range(n))
  582.         for proto in protocols:
  583.             s = self.dumps(x, proto)
  584.             y = self.loads(s)
  585.             self.assertEqual(x, y)
  586.             num_setitems = count_opcode(pickle.SETITEMS, s)
  587.             if proto == 0:
  588.                 self.assertEqual(num_setitems, 0)
  589.                 continue
  590.             self.failUnless(num_setitems >= 2)
  591.         
  592.  
  593.     
  594.     def test_simple_newobj(self):
  595.         x = object.__new__(SimpleNewObj)
  596.         x.abc = 666
  597.         for proto in protocols:
  598.             s = self.dumps(x, proto)
  599.             self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s), proto >= 2)
  600.             y = self.loads(s)
  601.             self.assertEqual(y.abc, 666)
  602.             self.assertEqual(x.__dict__, y.__dict__)
  603.         
  604.  
  605.     
  606.     def test_newobj_list_slots(self):
  607.         x = SlotList([
  608.             1,
  609.             2,
  610.             3])
  611.         x.foo = 42
  612.         x.bar = 'hello'
  613.         s = self.dumps(x, 2)
  614.         y = self.loads(s)
  615.         self.assertEqual(list(x), list(y))
  616.         self.assertEqual(x.__dict__, y.__dict__)
  617.         self.assertEqual(x.foo, y.foo)
  618.         self.assertEqual(x.bar, y.bar)
  619.  
  620.     
  621.     def test_reduce_overrides_default_reduce_ex(self):
  622.         for proto in (0, 1, 2):
  623.             x = REX_one()
  624.             self.assertEqual(x._reduce_called, 0)
  625.             s = self.dumps(x, proto)
  626.             self.assertEqual(x._reduce_called, 1)
  627.             y = self.loads(s)
  628.             self.assertEqual(y._reduce_called, 0)
  629.         
  630.  
  631.     
  632.     def test_reduce_ex_called(self):
  633.         for proto in (0, 1, 2):
  634.             x = REX_two()
  635.             self.assertEqual(x._proto, None)
  636.             s = self.dumps(x, proto)
  637.             self.assertEqual(x._proto, proto)
  638.             y = self.loads(s)
  639.             self.assertEqual(y._proto, None)
  640.         
  641.  
  642.     
  643.     def test_reduce_ex_overrides_reduce(self):
  644.         for proto in (0, 1, 2):
  645.             x = REX_three()
  646.             self.assertEqual(x._proto, None)
  647.             s = self.dumps(x, proto)
  648.             self.assertEqual(x._proto, proto)
  649.             y = self.loads(s)
  650.             self.assertEqual(y._proto, None)
  651.         
  652.  
  653.  
  654.  
  655. class REX_one(object):
  656.     _reduce_called = 0
  657.     
  658.     def __reduce__(self):
  659.         self._reduce_called = 1
  660.         return (REX_one, ())
  661.  
  662.  
  663.  
  664. class REX_two(object):
  665.     _proto = None
  666.     
  667.     def __reduce_ex__(self, proto):
  668.         self._proto = proto
  669.         return (REX_two, ())
  670.  
  671.  
  672.  
  673. class REX_three(object):
  674.     _proto = None
  675.     
  676.     def __reduce_ex__(self, proto):
  677.         self._proto = proto
  678.         return (REX_two, ())
  679.  
  680.     
  681.     def __reduce__(self):
  682.         raise TestFailed, "This __reduce__ shouldn't be called"
  683.  
  684.  
  685.  
  686. class MyInt(int):
  687.     sample = 1
  688.  
  689.  
  690. class MyLong(long):
  691.     sample = 0x1L
  692.  
  693.  
  694. class MyFloat(float):
  695.     sample = 1.0
  696.  
  697.  
  698. class MyComplex(complex):
  699.     sample = 1.0 + (0.0+0.0j)
  700.  
  701.  
  702. class MyStr(str):
  703.     sample = 'hello'
  704.  
  705.  
  706. class MyUnicode(unicode):
  707.     sample = u'hello \xe1\x88\xb4'
  708.  
  709.  
  710. class MyTuple(tuple):
  711.     sample = (1, 2, 3)
  712.  
  713.  
  714. class MyList(list):
  715.     sample = [
  716.         1,
  717.         2,
  718.         3]
  719.  
  720.  
  721. class MyDict(dict):
  722.     sample = {
  723.         'a': 1,
  724.         'b': 2 }
  725.  
  726. myclasses = [
  727.     MyInt,
  728.     MyLong,
  729.     MyFloat,
  730.     MyComplex,
  731.     MyStr,
  732.     MyUnicode,
  733.     MyTuple,
  734.     MyList,
  735.     MyDict]
  736.  
  737. class SlotList(MyList):
  738.     __slots__ = [
  739.         'foo']
  740.  
  741.  
  742. class SimpleNewObj(object):
  743.     
  744.     def __init__(self, a, b, c):
  745.         raise TypeError("SimpleNewObj.__init__() didn't expect to get called")
  746.  
  747.  
  748.  
  749. class AbstractPickleModuleTests(unittest.TestCase):
  750.     
  751.     def test_dump_closed_file(self):
  752.         import os
  753.         f = open(TESTFN, 'w')
  754.         
  755.         try:
  756.             f.close()
  757.             self.assertRaises(ValueError, self.module.dump, 123, f)
  758.         finally:
  759.             os.remove(TESTFN)
  760.  
  761.  
  762.     
  763.     def test_load_closed_file(self):
  764.         import os
  765.         f = open(TESTFN, 'w')
  766.         
  767.         try:
  768.             f.close()
  769.             self.assertRaises(ValueError, self.module.dump, 123, f)
  770.         finally:
  771.             os.remove(TESTFN)
  772.  
  773.  
  774.     
  775.     def test_highest_protocol(self):
  776.         self.assertEqual(self.module.HIGHEST_PROTOCOL, 2)
  777.  
  778.     
  779.     def test_callapi(self):
  780.         StringIO = StringIO
  781.         import cStringIO
  782.         f = StringIO()
  783.         self.module.dump(123, f, -1)
  784.         self.module.dump(123, file = f, protocol = -1)
  785.         self.module.dumps(123, -1)
  786.         self.module.dumps(123, protocol = -1)
  787.         self.module.Pickler(f, -1)
  788.         self.module.Pickler(f, protocol = -1)
  789.  
  790.  
  791.  
  792. class AbstractPersistentPicklerTests(unittest.TestCase):
  793.     
  794.     def persistent_id(self, object):
  795.         if isinstance(object, int) and object % 2 == 0:
  796.             self.id_count += 1
  797.             return str(object)
  798.         else:
  799.             return None
  800.  
  801.     
  802.     def persistent_load(self, oid):
  803.         self.load_count += 1
  804.         object = int(oid)
  805.         return object
  806.  
  807.     
  808.     def test_persistence(self):
  809.         self.id_count = 0
  810.         self.load_count = 0
  811.         L = range(10)
  812.         self.assertEqual(self.loads(self.dumps(L)), L)
  813.         self.assertEqual(self.id_count, 5)
  814.         self.assertEqual(self.load_count, 5)
  815.  
  816.     
  817.     def test_bin_persistence(self):
  818.         self.id_count = 0
  819.         self.load_count = 0
  820.         L = range(10)
  821.         self.assertEqual(self.loads(self.dumps(L, 1)), L)
  822.         self.assertEqual(self.id_count, 5)
  823.         self.assertEqual(self.load_count, 5)
  824.  
  825.  
  826.